Please address the comments from this code review:

## Overall Comments
- The state machine flags (`pending_stop`, `cancelled`) are now touched in several places with separate `inner.state.lock()` calls; consider centralizing these transitions into small helper methods on `SessionState` (e.g. `queue_stop_edge_during_starting`, `consume_pending_stop`, `mark_cancelled`) so that phase changes and flag updates always happen under a single, well-defined lock scope.
- In `cancel_session`, `cancelled` is set for any non-Idle phase even when `phase != Processing`, but in those branches you immediately move to `Idle` and `end_session` will never observe the flag; consider only setting `cancelled` when `phase == Processing` (or clearing it when you force `Idle`) to avoid confusing, stale state.

## Individual Comments

### Comment 1
<location path="openless-all/app/src-tauri/src/coordinator.rs" line_range="414-416" />
<code_context>
-            inner.state.lock().phase = SessionPhase::Listening;
+            // 转 Listening 同时检查 Starting 期间是否积累了 pending_stop 边沿。
+            // hold 模式快速松开 / toggle 快速双击会到这里：握手刚完就要立即停。
+            let should_stop_immediately = {
+                let mut state = inner.state.lock();
+                state.phase = SessionPhase::Listening;
+                std::mem::replace(&mut state.pending_stop, false)
+            };
</code_context>
<issue_to_address>
**issue (bug_risk):** Avoid blindly overwriting `phase` to `Listening` in case `cancel_session` ran concurrently

Within the `Recorder::start` success path, `state.phase` is always set to `Listening` inside `should_stop_immediately`. If `cancel_session` runs after `start` returns but before this lock is acquired, it may already have set `phase` to `Idle` and stopped the recorder/ASR. Resetting it to `Listening` can leave the coordinator in an inconsistent state (e.g., `Listening` with no active recorder). Please gate this assignment on the current `phase` (e.g., only transition `Starting -> Listening`) or no-op when the session has been cancelled/ended.
</issue_to_address>

### Comment 2
<location path="openless-all/app/src-tauri/src/coordinator.rs" line_range="611-615" />
<code_context>
     }
+    // Processing 阶段 cancel 不能直接干掉 in-flight polish task（已经 await 了），
+    // 但可以打 cancelled 标记，让 end_session 在插入前检查并丢弃结果。
+    inner.state.lock().cancelled = true;
+
     if let Some(rec) = inner.recorder.lock().take() {
</code_context>
<issue_to_address>
**suggestion (bug_risk):** Consider using a single `state` lock in `cancel_session` to avoid racey decisions based on a stale `phase` snapshot

Right now `cancel_session` reads `phase` under one `state` lock, then later re-locks `state` to set `cancelled = true` and maybe change `phase` based on the earlier snapshot. If `phase` can change between those two lock scopes, you may make decisions using stale state. Consider holding the lock once and doing the `phase` read plus `cancelled`/`phase` updates in a single critical section so they stay consistent.
</issue_to_address>